---
title: RAG 系统概述 | Kastrax 文档
description: Kastrax 中检索增强生成 (RAG) 的概述，详细说明其使用相关上下文增强 LLM 输出的能力。
---

# RAG 系统概述 ✅

Kastrax 检索增强生成 (RAG) 系统提供了一个全面的框架，用于构建结合大型语言模型和外部数据源的基于知识的应用程序。本指南解释了 RAG 系统架构以及如何有效地使用它。

## 什么是 RAG？ ✅

检索增强生成 (RAG) 是一种通过从外部知识源检索相关信息并将其纳入生成过程来增强语言模型输出的技术。这种方法有助于：

- 提供超出模型训练数据的最新信息
- 将响应基于事实、可验证的来源
- 减少幻觉并提高准确性
- 基于特定领域知识定制响应

## RAG 系统架构 ✅

Kastrax RAG 系统由几个组件组成：

1. **文档处理**：加载、分块和转换文档
2. **嵌入**：将文本转换为向量表示
3. **向量存储**：高效存储和检索向量
4. **检索**：基于查询查找相关信息
5. **重排序**：通过额外的排序提高检索质量
6. **上下文构建**：使用检索到的信息构建有效的提示
7. **生成**：使用增强的上下文生成响应

## 基本 RAG 流程 ✅

以下是在 Kastrax 中创建 RAG 流程的简单示例：

```kotlin
import ai.kastrax.rag.document.DocumentLoader
import ai.kastrax.rag.document.TextSplitter
import ai.kastrax.rag.embedding.EmbeddingModel
import ai.kastrax.rag.vectorstore.VectorStore
import ai.kastrax.rag.retrieval.Retriever
import ai.kastrax.rag.context.ContextBuilder
import ai.kastrax.core.agent.agent
import ai.kastrax.integrations.deepseek.deepSeek
import ai.kastrax.integrations.deepseek.DeepSeekModel
import kotlinx.coroutines.runBlocking

fun createRagPipeline() = runBlocking {
    // 1. 加载文档
    val loader = DocumentLoader.fromFile("knowledge_base.pdf")
    val documents = loader.load()
    
    // 2. 将文档分割成块
    val splitter = TextSplitter.recursive(
        chunkSize = 1000,
        chunkOverlap = 200
    )
    val chunks = splitter.split(documents)
    
    // 3. 创建嵌入
    val embeddingModel = EmbeddingModel.create("all-MiniLM-L6-v2")
    
    // 4. 存储在向量数据库中
    val vectorStore = VectorStore.create("chroma")
    vectorStore.addDocuments(chunks, embeddingModel)
    
    // 5. 创建检索器
    val retriever = Retriever.fromVectorStore(
        vectorStore = vectorStore,
        embeddingModel = embeddingModel,
        topK = 5
    )
    
    // 6. 创建上下文构建器
    val contextBuilder = ContextBuilder.create {
        template("""
            根据以下上下文回答问题：
            
            上下文：
            {{context}}
            
            问题：{{query}}
            
            回答：
        """.trimIndent())
    }
    
    // 7. 创建 RAG 代理
    val ragAgent = agent {
        name("RAG代理")
        description("一个具有 RAG 能力的代理")
        
        // 配置 LLM
        model = deepSeek {
            apiKey("your-deepseek-api-key")
            model(DeepSeekModel.DEEPSEEK_CHAT)
            temperature(0.7)
        }
        
        // 配置 RAG
        rag {
            retriever(retriever)
            contextBuilder(contextBuilder)
            maxTokens(3000)
        }
    }
    
    // 使用 RAG 代理
    val query = "Kastrax 的主要特点是什么？"
    val response = ragAgent.generate(query)
    println(response.text)
}
```

## 文档处理 ✅

### 加载文档 ✅

Kastrax 支持从各种来源加载文档：

```kotlin
// 从文件加载
val fileLoader = DocumentLoader.fromFile("document.pdf")

// 从目录加载
val dirLoader = DocumentLoader.fromDirectory("documents/")

// 从 URL 加载
val webLoader = DocumentLoader.fromUrl("https://example.com/document")

// 从数据库加载
val dbLoader = DocumentLoader.fromDatabase(
    connection = dbConnection,
    query = "SELECT content FROM documents"
)
```

### 文档格式 ✅

Kastrax 支持多种文档格式：

- PDF
- Word (DOCX)
- 文本
- HTML
- Markdown
- CSV
- JSON
- XML
- 数据库

### 分块文档 ✅

文档可以被分割成块以便更好地处理：

```kotlin
// 递归文本分割器（按段落、句子等分割）
val recursiveSplitter = TextSplitter.recursive(
    chunkSize = 1000,
    chunkOverlap = 200
)

// 字符文本分割器
val charSplitter = TextSplitter.byCharacter(
    chunkSize = 1000,
    chunkOverlap = 200,
    separator = "\n\n"
)

// 令牌文本分割器
val tokenSplitter = TextSplitter.byToken(
    chunkSize = 500,
    chunkOverlap = 100,
    encoderName = "cl100k_base" // OpenAI 的分词器
)

// 语义文本分割器
val semanticSplitter = TextSplitter.semantic(
    embeddingModel = embeddingModel,
    similarityThreshold = 0.7
)
```

## 嵌入 ✅

### 嵌入模型 ✅

Kastrax 支持各种嵌入模型：

```kotlin
// 使用本地模型
val localModel = EmbeddingModel.create("all-MiniLM-L6-v2")

// 使用 OpenAI 嵌入
val openAiModel = EmbeddingModel.openAi(
    apiKey = "your-openai-api-key",
    model = "text-embedding-3-small"
)

// 使用自定义嵌入
val customModel = EmbeddingModel.custom(
    embeddingFunction = { text ->
        // 自定义嵌入逻辑
        floatArrayOf(/* ... */)
    },
    dimensions = 384
)
```

## 向量存储 ✅

### 向量存储 ✅

Kastrax 支持多种向量存储：

```kotlin
// 内存向量存储
val memoryStore = VectorStore.inMemory()

// Chroma 向量存储
val chromaStore = VectorStore.chroma(
    collectionName = "documents",
    url = "http://localhost:8000"
)

// FAISS 向量存储
val faissStore = VectorStore.faiss(
    indexPath = "faiss_index",
    dimensions = 384
)

// Pinecone 向量存储
val pineconeStore = VectorStore.pinecone(
    apiKey = "your-pinecone-api-key",
    environment = "us-west1-gcp",
    index = "documents"
)
```

## 检索 ✅

### 检索器 ✅

检索器基于查询查找相关信息：

```kotlin
// 向量存储检索器
val vectorRetriever = Retriever.fromVectorStore(
    vectorStore = vectorStore,
    embeddingModel = embeddingModel,
    topK = 5
)

// 关键词检索器
val keywordRetriever = Retriever.keyword(
    documents = documents,
    topK = 5
)

// 混合检索器（结合向量和关键词搜索）
val hybridRetriever = Retriever.hybrid(
    vectorRetriever = vectorRetriever,
    keywordRetriever = keywordRetriever,
    vectorWeight = 0.7,
    keywordWeight = 0.3
)
```

## 重排序 ✅

### 重排序器 ✅

重排序器提高检索质量：

```kotlin
// 交叉编码器重排序器
val crossEncoderReranker = Reranker.crossEncoder(
    model = "cross-encoder/ms-marco-MiniLM-L-6-v2",
    topK = 3
)

// LLM 重排序器
val llmReranker = Reranker.llm(
    llm = deepSeekLlm,
    prompt = "根据与查询的相关性对这些文档进行排名：{{query}}\n\n文档：\n{{documents}}",
    topK = 3
)
```

## 完整 RAG 示例 ✅

以下是一个复杂 RAG 系统的完整示例：

```kotlin
import ai.kastrax.rag.*
import ai.kastrax.core.agent.agent
import ai.kastrax.integrations.deepseek.deepSeek
import ai.kastrax.integrations.deepseek.DeepSeekModel
import kotlinx.coroutines.runBlocking

fun createAdvancedRagSystem() = runBlocking {
    // 1. 加载和处理文档
    val loader = DocumentLoader.fromDirectory("knowledge_base/")
    val documents = loader.load()
    
    val splitter = TextSplitter.recursive(
        chunkSize = 1000,
        chunkOverlap = 200
    )
    val chunks = splitter.split(documents)
    
    // 2. 设置嵌入和向量存储
    val embeddingModel = EmbeddingModel.create("all-MiniLM-L6-v2")
    val vectorStore = VectorStore.chroma("kastrax_docs")
    
    // 3. 将文档添加到向量存储
    vectorStore.addDocuments(
        documents = chunks,
        embeddingModel = embeddingModel
    )
    
    // 4. 创建混合检索器
    val vectorRetriever = Retriever.fromVectorStore(
        vectorStore = vectorStore,
        embeddingModel = embeddingModel,
        topK = 10
    )
    
    val keywordRetriever = Retriever.keyword(
        documents = chunks,
        topK = 10
    )
    
    val hybridRetriever = Retriever.hybrid(
        vectorRetriever = vectorRetriever,
        keywordRetriever = keywordRetriever,
        vectorWeight = 0.7,
        keywordWeight = 0.3
    )
    
    // 5. 添加重排序
    val reranker = Reranker.crossEncoder(
        model = "cross-encoder/ms-marco-MiniLM-L-6-v2",
        topK = 5
    )
    
    val enhancedRetriever = Retriever.withReranker(
        baseRetriever = hybridRetriever,
        reranker = reranker
    )
    
    // 6. 创建带压缩的上下文构建器
    val contextBuilder = ContextBuilder.create {
        template("""
            你是 Kastrax（一个强大的 AI 代理框架）的有帮助的助手。
            根据以下来自 Kastrax 文档的上下文回答问题。
            
            上下文：
            {{#each documents}}
            文档 {{@index}}（来源：{{metadata.source}}）：
            {{pageContent}}
            
            {{/each}}
            
            问题：{{query}}
            
            仅使用上下文中提供的信息回答问题。
            如果你没有足够的信息，请说"我没有足够的信息。"
            提供信息时，始终引用源文档。
        """.trimIndent())
        
        compression {
            enabled(true)
            method(CompressionMethod.MAP_REDUCE)
            maxTokens(3000)
        }
    }
    
    // 7. 创建 RAG 代理
    val ragAgent = agent {
        name("Kastrax文档助手")
        description("一个帮助处理 Kastrax 文档的助手")
        
        // 配置 LLM
        model = deepSeek {
            apiKey("your-deepseek-api-key")
            model(DeepSeekModel.DEEPSEEK_CHAT)
            temperature(0.3) // 较低的温度以获得更事实性的响应
        }
        
        // 配置 RAG
        rag {
            retriever(enhancedRetriever)
            contextBuilder(contextBuilder)
            maxTokens(3000)
        }
    }
    
    // 8. 使用 RAG 代理
    val query = "我如何在 Kastrax 中实现自定义工具？"
    val response = ragAgent.generate(query)
    println(response.text)
}
```

## 下一步 ✅

现在您已经了解了 RAG 系统，您可以：

1. 了解[文档处理](./document-processing.mdx)
2. 探索[向量存储](./vector-stores.mdx)
3. 实现[高级检索技术](./advanced-retrieval.mdx)
4. 设置[RAG 评估](./evaluation.mdx)
